# TSPoet

## TSPoet est une bibliothèque TS/JS pour générer des fichiers source .ts

La génération de fichier .ts pourras vous être utile lors d’exécution de processus en générant du code TypeScript (par exemple : lors d’une exécution d’une commande NPM).

#### Installation 
![node-current](https://img.shields.io/node/v/@msay2/tspoet?color=00ACC1&style=for-the-badge) ![npm](https://img.shields.io/npm/v/@msay2/tspoet?color=00ACC1&style=for-the-badge) ![npm](https://img.shields.io/npm/dm/@msay2/tspoet?color=00ACC1&style=for-the-badge) ![NPM](https://img.shields.io/npm/l/@msay2/tspoet?color=00ACC1&style=for-the-badge)

# Journal
##### Si vous êtes sur une version antérieure à la version 3.0.0 veuillez jeter un oeil au journal des modifications (La version 3.0.0 est une grosse mise à jour qui ajoute, supprime et renomme beaucoup d'elements !)
<a href="https://github.com/MSay2/TSPoet/blob/master/changelog.md">Journal des modifications</a>

##### Cette bibliothèque peut s’exécuter avec les fichiers .mjs
cli.mjs
```javascript
import packages from "@msay2/tspoet";
const { TSType, TSMethod, Modifier, TypeName} = packages;
```

### Exemple
Voici un code simple
```typescript
import { Manager } from "build/generated/Manager.js";

export class Fragment extends Manager
{
	public onView():void{
		super.onView();
	}
}
```

Voici son équivalant généré avec TSPoet (don le fichier TypeScript portera le même nom que son nom de classe).
``` typescript
let fragmentClassBuilder = TSType.classBuilder("Fragment")
    .addImport("build/generated/", "Manager")
    .addModifiers(Modifier.EXPORT)
    .setSuperclass(TypeName.get("Manager"));

let frgamentOnViewBuilder = TSMethod.methodBuilder("onView")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID)
    .addStatement("super.onView();"));

fragmentClassBuilder.addMethod(frgamentOnViewBuilder.build());

TSPoet.writeFile("app/", fragmentClassBuilder.build());
```

Pour déclarer notre classe `Fragment` ainsi que sa méthode `Fragment.onView` nous devons entamer la création d’un type d’élément TypeScript avec l’object `TSType`.  
Nous configurons la classe `Fragment` en y ajoutant une importation, puis en ajoutant un modificateur qui configurera la portée de notre classe, ensuite nous ajoutons une classe à étendre de l’objet `Manager`.  
Une fois la configuration de la classe `Fragment` nous devons ajouter une méthode d’implémentation à notre classe avec l’objet `TSMethod` que l’on nomme `onView`.  
La méthode `Fragment.onView` sera configurée avec une portée `public` puis avec une valeur de retour typée `void` puis nous ajoutons une ligne de code.    

Une fois les configurations terminées, nous pouvons « écrire » notre fichier en demandant à l’objet `TSPoet` de créer notre futur objet à partir des configurations de constructions citées plus haut, avec la méthode `TSPoet.writeFile`.    

# /!\ Avertissement /!\ 
### La bibliothèque TSPoet est encore en développement (des changements seront à venir).    

`TSPoet` propose aussi la possibilité de créer des interfaces, énumérations, éléments personnalisées et des déclarations de type ou de variable.

* Classes -> `TSType.classBuilder`
* Interfaces -> `TSType.interfaceBuilder` 
* Énumérations -> `TSType.enumBuilder`
* Éléments personnalisées -> `TSType.customElementBuilder`
* Type ou Var -> `TSType.declarableBuilder`

La configuration des méthodes, propriétées…etc n’étant pas modélisées, tous les paramètres appliqués pour la configuration de vos objets sont modélisés par `TSPoet` par de simples chaînes de caractères, ainsi que vos lignes de codes :

```typescript
let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(TypeName.TYPE_VOID)
    .addStatement("let index:number = 0;" +
    "let value:boolean = true;" +
    "while (value)" +
    "{" +
    "console.log(`Index=[${value}]`);" +
    "index++;" +
    "if (index == 20)" +
    "{" +
    "value = false;" +
    "}" +
    "}")
    .build();
```

Ce qui générerait :
```typescript
doLoop():void{
	let index:number = 0;let value:boolean = true;while (value){console.log(`Index=[${value}]`);index++;if (index == 20){value = false;}}
}
```

Pour remédier à ce genre de pratique fastidieuse, `TSPoet` comprend l’objet `CodeBlock` qui vous permettra d’écrire vos ligne de code bloc par bloc :
```typescript
let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(TypeName.TYPE_VOID)
    .addCodeBlock(CodeBlock.new()
        .addStatement("let index:number = 0, value:boolean = true")
        .beginBrace("while (value)")
        .addStatement("console.log(`Index=[${value}]`)")
        .addStatement("index++")
        .beginBrace("if (index == 20)")
        .addStatement("value = false")
        .endBrace()
        .endBrace()
        .build())
    .build();
```
Ce qui générerait :
```typescript
doLoop():void{
    let index:number = 0, value:boolean = true;
    while (value){
        console.log(`Index=[${value}]`);
        index++;
        if (index == 20){
            value = false;
        }
    }
}
```

Concrètement, l’objet `CodeBlock` vous permet d’ajouter du code complexe, contrairement à la méthode par défaut `TSMethod.addStatement` qui vous permet d’ajouter vos lignes de codes SIMPLEMENT.  
L'utilisation de l'objet `CodeBlock` est recommandé, celui-ci gère les indentations, les accolades et les points-virgules. 

La méthode `CodeBlock.addStatement` insert vos lignes de codes et gère les indentations.   
La méthode `CodeBlock.beginBrace` insert une accolade ouvrante.   
La méthode `CodeBlock.endBrace` insert une accolade fermante.   
La méthode `CodeBlock.nextBrace` insert une accolade fermante puis ouvrante.   

### Créations

#### Classes
Créer une classe 
```typescript
let componentClassBuilder = TSType.classBuilder("Component").build();
```
Ce qui générerait
```typescript
class Component
{
}
```
Un fichier TypeScript sera généré au nom de votre classe (soit Component.ts)

#### Interfaces
Créer une interface
```typescript
let managerInterfaceBuilder = TSType.interfaceBuilder("Manager").build();
```
Ce qui générerait
```typescript
interface Manager
{
}
```

#### Enumérations
Créer une énumération
```typescript
let managerEventEnumBuilder = TSType.enumBuilder("EventManager").build();
```
Ce qui générerait
```typescript
enum EventManager
{
}
```

#### Éléments personnalisés
Créer un élément personnalisé
```typescript
let viewCustomElementBuilder = TSType.customElementBuilder("my-view")
    .setSuperclass("div")
    .setObject(TSObject.get("MyCustomView"))
    .build();
```
###### (lisez plus bas pour en savoir plus sur l'objet `TSObject`)
Ce qui générerait
```typescript
customElements.define("my-view", MyCustomView, {extends: "div"});
```

#### Déclaration
##### Type
```typescript
let declarableBuilder = TSType.declarableBuilder()
    .forType("MyType")
    .addModifiers(Modifier.EXPORT)
    .return(TypeName.TYPE_STRING)
    .build();
```
Ce qui gégénerait
```typescript
export declare type MyType = string; 
```
##### Var
```typescript
let interfaceBuilder = TSType.interfaceBuilder("MyInterface")
    .addProperty(TSProperty.add("from")
        .return(TypeName.TYPE_NUMBER)
        .build())
    .addProperty(TSProperty.add("new")
        .addParameter("name", TypeName.TYPE_STRING)
        .build());

let declarableBuilder = TSType.declarableBuilder()
    .forVar()
    .add(interfaceBuilder)
    .build();
```
Ce qui générerait
```typescript
declare var MyInterface:
{
    from:number;
    new(name:string):any
}
```

#### Objet
Créer l'objet configuré
```typescript
let classBuilder = ...;


TSPoet.writeFile("./app", classBuilder.build());
```
Ce qui générerait un ficher TypeScript au nom de votre objet `classBuilder` dans un dossier nommé `app`.  

### Bloc de code (bonnes pratiques)
L’objet `CodeBlock` possède une fonctionnalité vous permettant de ne plus écrire du code fastidieux (comprenant plusieurs caractères additionnelles pour la concaténation d’expressions littérales).  

##### Pratiques
###### Mauvaise pratique
```typescript
let enableChatBuilder = TSMethod.methodBuilder("enableChat")
    .addCodeBlock(CodeBlock.new()
        .addStatement("let count:number = 0")
        .beginBrace("for (let i:number = 0; i < 20; i++)")
        .addStatement("count += i")
        .endBrace()
        .buil())
    .build();
```
###### Pratique moins mauvaise
```typescript
public static createMethod(from:number, to:number):void
{
    let counterBuilder = TSMethod.methodBuilder("counter")
        .addCodeBlock(CodeBlock.new()
            .addStatement("let count:number = 0")
            .beginBrace("for (let i:number = "+ from +"; i < "+ to +"; i++)")
            .addStatement("count += i")
            .endBrace()
            .buil())
        .build();
}
```
Pour éviter ces mauvaises pratiques, `CodeBlock` possède 3 expressions vous permettant d’éviter toutes les concaténations « agaçantes ».  

###### Bonne pratiques
```typescript
let counterBuilder = TSMethod.methodBuilder("counter")
    .addCodeBlock(CodeBlock.new()
        .addStatement("let count:number = 0")
        .beginBrace("for (let i:number = $L; i < $L; i++)", 0, 20)
        .addStatement("count += i")
        .endBrace()
        .buil())
    .build();
```

L’objet `CodeBlock` vous donne la possibilité d’insérer vos lignes de code de manière similaire à la méthode `string.replace`.  

###### Pour les expressions littérales
```typescript
…
.beginBrace("for (let i:number = $L; i < $L; i++)", 0, 20)
…
```
###### Pour les chaînes de caractères
```typescript
…
.beginBrace("let firstName:string = $S, lastName:string = $S", "Manon", "Carcer")
…
```

###### Pour les objets
```typescript
…
.beginBrace("let myObject:$O = new $O()", TSObject.get("MyObject"), TSObject.get("MyObject"))
…
```

#### Importations
```typescript
let classBuilder = TSType.classBuilder("MyClass")
    .addImport("./", "Map", "LinkedMap")
    .build();
```
Ce qui générerait
```typescript
import { Map, LinkedMap } from "./LinkedMap.js";

export class MyClass
{
}
```

#### Méthodes
###### Note : Si vous appliquez un modificateur abstrait à un constructeur de méthode qui est pourvus d’une ligne de code (ou d’un bloc de code), ces dernières seront ignorées du fait que les méthodes abstraites ne doivent pas avoir de corp.
Créer une méthode
```typescript
let checkValueBuilder = TSMethod.methodBuilder("checkValue")
    .addModifiers(Modifier.PUBLIC, Modifier.ABSTRACT);

let checkerBuilder = TSMethod.methodBuilder("checker")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID);

let checkClassBuilder = TSType.classBuilder("Checker")
    .addModifiers(Modifier.EXPORT, Modifier.ABSTRACT)
    .addMethod(checkValueBuilder.build())
    .addMethod(checkerBuilder.build())
    .build();
```
Ce qui générerait
```typescript
export abstract class Checker
{
	public abstract checkValue()

	public checker():void{}
}
```
#### Paramètres
```typescript
let overBuilder = TSMethod.methodBuilder("over")
    .addModifiers(Modifier.PRIVATE)
    .return(TypeName.TYPE_VOID)
    .addParameter("value", TypeName.TYPE_BOOLEAN)
    .addParameter("name", TypeName.TYPE_STRING)
    .build();
```
Ce qui générerait
```typescript
private over(value:boolean, name:string):void{}
```
#### Constructeur
###### 
```typescript
let constructorBuilder = TSMethod.constructorBuilder()
    .addModifiers(Modifier.PROTECTED)
    .build();
```
Ce qui générerait
```typescript
protected constructor(){}
```

#### Variables
###### Note : L’objet `TSVariable` est un constructeur, veillez à toujours appeler la méthode `build`.
```typescript
let myVar = TSVariable.add("my_var")
    .addModifiers(Modifier.STATIC)
    .return(TypeName.TYPE_ANY)
    .setValue({
        from: 0,
        to: 255
    });

let countVar = TSVariable.add("count")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_NUMBER)
    .setValue(48)

let vargClassBuilder = TSType.classBuilder("Varg")
    .addVariable(myVar.build())
    .addVariable(countVar.build())
    .build();
```
Ce qui générerait
```typescript
class Varg
{
    static my_var:any = {from: 0, to: 255};
    public count:number = 48;
}
```

#### Interfaces
###### Note : L’objet `TSProperty` est un constructeur, veillez à toujours appeler la méthode `build`.
```typescript
let testRobotPropertyBuilder = TSProperty.add("testRobot")
    .addParameter("hasProperties", TypeName.TYPE_BOOLEAN)
    .addParameter("list", TypeName.get("Array").transtypeTo("string"))
    .return(TypeName.get("Array").transtypeTo("string"));

let fetcherPropertyBuilder = TSProperty.add("fetcher")
    .return(TypeName.TYPE_STRING);

let robotInterface = TSType.interfaceBuilder("Robot")
    .addProperty(testRobotPropertyBuilder.build())
    .addProperty(fetcherPropertyBuilder.build())
    .build();
```

Ce qui générerait
```typescript
interface Robot
{
    testRobot(hasProperties:boolean, list:Array<string>):Array<string>;
    fetcher:string;
}
```

#### Annotations
###### Note : L’objet `TSAnnotation` est un constructeur, veillez à toujours appeler la méthode `build`.
```typescript
let object = {
    template: "<p>Paragraph</p>"
};

let fooAnnotation = TSAnnotation.add("Foo").addValue(object);
let barAnnotation = TSAnnotation.add("Bar").addValue(TSAnnotation.EMPTY_VALUE);
let booAnnotation = TSAnnotation.add("Boo");

let byeBuilder = TSMethod.methodBuilder("bye")
    .addAnnotation(fooAnnotation.build())
    .addAnnotation(barAnnotation.build())
    .addAnnotation(booAnnotation.build())
    .build();
```

Ce qui générerait
```typescript
@Foo({
    template: `<p>Paragraph</p>`
})
@Bar()
@Boo
bye(){}
```

#### Enumération
###### Note : L’objet TSConstant est un constructeur, veillez à toujours appeler la méthode `build`
```typescript
let constantUpTouch = TSConstant.add("UP", 0);
let constantDownTouch = TSConstant.add("DOWN", 1);

let onTouchEnum = TSType.enumBuilder("OnTouch")
    .addConstant(constantUpTouch.build())
    .addConstant(constantDownTouch.build())
    .build();
```

Ce qui générerait
```typescript
enum OnTouch
{
	UP = 0,
	DOWN = 1,
}
```

#### Déclaration
Pour créer une déclaration de variable vous devez utiliser l’objet enfant `InterfaceBuilder` avec la méthode `TSType.interfaceBuilder` (l’insertion d’une classe à étendre sera ignorée ainsi que son transtypage)
```typescript
let robotBuilder = TSType.interfaceBuilder("Robot")
    .setSuperclass(TypeName.get("List").transtypeTo("string"))
    .addImport("./", "List", "ArrayList")
    .addModifiers(Modifier.EXPORT)
    .addProperty(TSProperty.add("test")
        .addParameter("hasProperties", TypeName.TYPE_BOOLEAN)
        .addParameter("list", TypeName.get("List").transtypeTo("string", "boolean"))
        .return(TypeName.get("List").transtypeTo("string", "boolean"))
        .build())
    .addProperty(TSProperty.add("new")
        .addParameter("name", TypeName.TYPE_STRING)
        .build())
    .addProperty("fetch", TypeName.TYPE_STRING)
    .addProperty("jaune", TypeName.get("List").transtypeTo("string", "boolean"))
    .transtypeTo("B");

let declarableBuilder = TSType.declarableBuilder()
    .forVar()
    .add(interfaceBuilder)
    .build();
```

Ce qui générerait
```typescript
import { List, ArrayList } from "./ArrayList.js";
export declare var MyInterface:
{
    test(hasProperties:boolean, list:List<string, boolean>):List<string, boolean>;
    new(name:string):void;
	fetch:string;
	jaune:List<string, boolean>;
}
```
Pour créer une déclaration de type
```typescript
let typeDeclarable = TSType.declarableBuilder()
    .forType("Class")
    .addModifiers(Modifier.EXPORT)
    .return(TypeName.TYPE_BOOLEAN)
    .build();
```

Ce qui générerait
```typescript
export declare type Class = boolean;
```

#### Commentaire
Pour ajouter des commentaires vous devez utiliser la méthode `CodeBlock.addComment`
```typescript
let doLoopBuilder = TSMethod.methodBuilder("doLoop")
    .return(TypeName.TYPE_VOID)
    .addCodeBlock(CodeBlock.new()
        .addStatement("let index:number = 0, value:boolean = true")
        .beginBrace("while (value)")
        .addStatement("console.log(`Index=[${value}]`)")
        .addStatement("index++")
        .addComment("Check if index equals 20")
        .beginBrace("if (index == 20)")
        .addStatement("value = false")
        .endBrace()
        .endBrace()
        .build())
    .build();
```
Ce qui générerait
```typescript
private doLoop():void{
    let index:number = 0, value:boolean = true;
    while (value){
        console.log(`Index=[${value}]`);
        index++;
        // Check if index equals 20
        if (index == 20){
            value = false;
        }
    }
}
```
#### Documentation
Pour ajouter une documentation vous devez utiliser la méthode `addDoc` des objets suivants :
* `ClassBuilder`
* `EnumBuilder`
* `InterfaceBuilder`
* `TSProperty`
* `TSConstant`
* `TSMethod`

###### Exemple avec le constructeur de méthode.
```typescript
let setNameMethod = TSMethod.methodBuilder("setName")
    .addModifiers(Modifier.PUBLIC)
    .return(TypeName.TYPE_VOID)
    .addDoc("Set the name of user.")
    .addDoc("@param name the name of user.")
    .addParameter("name", TypeName.TYPE_STRING)
    .addStatement("this.name = name;")
    .build();
```
Ce qui générerait
```typescript
/**
 * Set the name of user.
 * @param name the name of user.
 */
public setName(name:string):void{
    this.name = name;
}
```

#### Génération
Pour générer des fichiers TypeScript, vous devez utiliser l’objet `TSPoet`.  

Écrire dans un fichier en remplaçant l’ancien contenu
```typescript
let path:string = "app/draw";

let classBuilder = TSType.classBuilder("MyClass")
    ...;
let interfaceBuilder = TSType.interfaceBuilder("MyInterface")
    ...;
let enumBuilder = TSType.enumBuilder("MyEnumeration")
    ...;

TSPoet.writeFile(path, classBuilder.build());
TSPoet.writeFile(path, interfaceBuilder.build());
TSPoet.writeFile(path, enumBuilder.build());
```
Écrire dans un fichier sans remplacer l’ancien contenu 
```typescript
let path:string = "app/draw";
let fileName:string = "MyClass";

let classBuilder = ...;
let interfaceBuilder  = ...;
let enumBuilder  = ...;

TSPoet.writeInFile(path, fileName, classBuilder.build());
TSPoet.writeInFile(path, fileName, interfaceBuilder.build());
TSPoet.writeInFile(path, fileName, enumBuilder.build());
```
Créer un fichier sans contenue
```typescript
let path:string = "app/draw"
let fileName:string = "MyClass.ts";

TSPoet.createFileStream(path, fileName);
```

## Référentiel d'objets
### Objets de modélisations principales

##### TSType
| Méthodes | Modificateurs | Descriptions | Types |
| -------- | ------------- | ------------ | ----- |
| classBuilder | public static | Joindre le constructeur de classe | ClassBuilder |
| enumBuilder | public static | Joindre le constructeur d’énumération | EnumBuilder |
| interfaceBuilder | public static | Joindre le constructeur d’interface | InterfaceBuilder |
| customElementBuilder | public static | Joindre le constructeur d’élément personnalisé | CustomElementBuilder |
| declarableBuilder | public static | Joindre le constructeur de déclaration de type ou variable | DeclarableBuilder |

#### ClassBuilder
| Méthodes | Paramètres | Descriptions | Types |
| -------- | ---------- | ------------ | ----- |
| addImport | string, ...string[] | Ajoute un importation | ClassBuilder |
| addDoc | string | Ajoute une documentation | ClassBuilder |
| addModifiers | ...Modifier[] | Ajoute des modificateurs | ClassBuilder |
| addAnnotation | TSAnnotation | Ajoute une annotation | ClassBuilder |
| addMethod | TSMethod | Ajoute une méthode | ClassBuilder |
| addVariable | TSVariable | Ajoute une variable | ClassBuilder |
| setSuperclass | TypeName | Ajoute une classe à étendre | ClassBuilder |
| addInterface | TypeName | Ajoute une interface d'implémentation | ClassBuilder |
| transtypeTo | string | Transtype votre classe | ClassBuilder |
| build | X | Initialise la construction | TSType |

#### EnumBuilder
| Méthodes | Paramètres | Descriptions | Types |
| -------- | ---------- | ------------ | ----- |
| addModifiers | ...Modifier[] | Ajoute des modificateurs | EnumBuilder |
| addDoc | string| Ajoute une documentation | EnumBuilder |
| addConstant | TSConstant | Ajoute une constante | EnumBuilder |
| build | X | Initialise la construction | TSType |

#### InterfaceBuilder
| Méthodes | Paramètres | Descriptions | Types |
| -------- | ---------- | ------------ | ----- |
| addImport | string, ...string[] | Ajoute une importation | InterfaceBuilder |
| addDoc | string | Ajoute une documentation | InterfaceBuilder |
| setSuperclass | TypeName | Ajoute une classe d'extension | InterfaceBuilder |
| addModifiers | ...Modifier[] | Ajoute des modificateurs | InterfaceBuilder |
| addProperty | TSProperty | Ajoute une méthode ou propriété | InterfaceBuilder |
| transtypeTo | string | Transtype votre interface | InterfaceBuilder |
| build | X | Initialise la construction | TSType |

#### CustomElementBuilder
| Méthodes | Paramètres | Descriptions | Types |
| -------- | ---------- | ------------ | ----- |
| setObject | TSObject | Définie l'objet personnalisé | CustomElementBuilder |
| setSuperclass | string | Définie l'objet html à étendre | CustomElementBuilder |
| build | X | Initialise la construction | TSType |

#### DeclarableBuilder
| Méthodes | Paramètres | Description | Types |
| -------- | ---------- | ----------- | ----- |
| forVar | X | Joindre le constructeur de déclaration de variable | DeclarableVar |
| forType | string | Joindre le constructeur de déclaration de type | DeclarableType |

#### DeclarableVar
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| add | public | InterfaceBuilder | Définie la déclaration de variable. Cette méthode ignore l'insertion de la classe étendue et le transtypage | DeclarableVar |
| build | public | X | Initialise la construction de la déclaration | TSType |

#### DeclarableType
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| addModifiers | public | ...Modifier[] | Ajoute des modificateurs | DeclarableType |
| return | public | TypeName | Définie une valeur de retour | DeclarableType |
| build | public | X | Initialise la construction de la déclaration |

### Objets de modélisations complémentaires

#### TSProperty
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| add | public static | string | Définie le nom de la propriété ou méthode | Builder |
| addParameter | public | string, ...string[] | Ajoute un paramètre | Builder |
| addDoc | public | string | Ajoute une documentation | Builder |
| return | public | TypeName | Définie une valeur de retour | Builder |
| build | public | X | Initialise la construction de la propriété ou méthode | TSProperty |

#### TSVariable
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| add | public static | string | Ajoute une variable en spécifant son nom | Builder |
| addModifiers | public | ...Modifier[] | Ajoute des modificateurs | Builder |
| return | public | TypeName | Definie une valeur de retour | Builder |
| setValue | public | any | Définie une valeur | Builder |
| build | public | X | Initialise la construction de la variable | TSVariable |

#### TSObject
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| get | public static | string | Définie le nom de l'objet souhaité | TSObject |

#### TSAnnotation
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| add | public static | string | Définie une annotation | Builder |
| addValue | public | any | Ajoute une valeur en paramètre | Builder |
| build | public | X | Initialise la construction de l'annotation | TSAnnotation |

#### TSConstant
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| add | public static | string, string | Définie le nom de la constante | Builder |
| addDoc | public | string | Ajoute une documentation | Builder |
| build | public | X | Initialise la construction de la constante | TSConstant |

#### TSMethod
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------ | ---------- | ------------ | ----- |
| constructorBuilder | public static | X | Ajoute un constructeur | Builder |
| methodBuilder | public static | string | Ajoute une méthode | Builder |
| addModifiers | public | ...Modifier[] | Ajoute des modificateurs | Builder |
| addDoc | string | Ajoute une documentation | Builder |
| addAnnotation | public | TSAnnotation | Ajoute une annotation | Builder |
| addStatement | public | string | Ajoute une ligne de code | Builder |
| addCodeBlock | public | CodeBlock | Ajoute un bloc de code | Builder |
| addParameter | public | string, TypeName | Ajoute un paramètre | Builder |
| transtypeTo | public | ...string[] | Transtype la méthode | Builder |
| return | public | TypeName | Définie une valeur de retour | Builder |
| build | public | X | Initialise la construction de la méthode | TSMethod |

#### CodeBlock
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| new | public static | X | Obtenir le constructeur | Builder |
| addStatement | public | string, ...any[] | Ajoute une ligne de code | Builder |
| addCodeBlock | public | CodeBlock | Ajoute un block de code | Builder |
| beginBrace | public | ?string, ...any[] | Insert une accolade ouvrante | Builder |
| nextBrace | public | ?string, ...any[] | Insert une accolade ouvrante et fermante | Builder |
| endBrace | public | ?boolean | Insert une accolade fermante | Builder |
| addComment | public | string | Ajoute un commentaire | Builder |
| build | public | X | Initialise le bloc de code | CodeBlock |

#### TypeName
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| get | public static | string | Définie le nom du type | TypeName |
| transtypeTo | public | ...string[] | Transtype le type d'objet | TypeName |
| TYPE_VOID | public static | X | Définie le type Void | TypeName |
| TYPE_BOOLEAN | public static | X | Définie le type Boolean | TypeName |
| TYPE_STRING | public static | X | Définie le type String | TypeName |
| TYPE_NUMBER | public static | X | Définie le type Number | TypeName |
| TYPE_ANY | public static | X | Définie le type Any | TypeName |

#### Modifier
| Constantes |
| ---------- |
| EXPORT |
| PUBLIC |
| STATIC |
| PRIVATE |
| ABSTRACT |
| PROTECTED |
| READONLY |

#### TSPoet
| Méthodes | Modificateurs | Paramètres | Descriptions | Types |
| -------- | ------------- | ---------- | ------------ | ----- |
| createFileStream | public static | string, string | Crée un fichier | void |
| writeInFile | public static | string, string, TSType | Écrit dans un fichier sans effacer l'ancien contenu | void |
| writeFile | public static | string, TSType | Écrit dans un fichier en remplaçant l'ancien contenu | void |

# License
```
Copyright (c) 2020 MSay2, Yoann Meclot - @msay2/tspoet
 
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
 
    http://www.apache.org/licenses/LICENSE-2.0
 
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
```